Android
Memory
Leaks

// ✗ Static Activity reference — rotates once = 1 leaked Activity + full view hierarchy
object AnalyticsManager {
    var currentActivity: Activity? = null  // LEAKS on rotation
}

// ✗ Static View reference — View holds Context (Activity)
companion object {
    private var cachedView: View? = null  // entire window hierarchy kept alive
}

// ✗ Singleton holding Application context used as Activity context
class ImageLoader private constructor(val context: Context) {
    companion object {
        fun init(context: Context) = ImageLoader(context)  // pass Activity accidentally
    }
}

// ✓ Never store Activity in static field. Use callbacks or WeakReference.
object AnalyticsManager {
    private var activityRef: WeakReference<Activity>? = null
    fun attach(a: Activity) { activityRef = WeakReference(a) }
    fun detach() { activityRef = null }  // call in onDestroy
}

// ✓ Singletons should use Application context, never Activity context
class ImageLoader private constructor(val context: Context) {
    companion object {
        fun init(context: Context) = ImageLoader(context.applicationContext)
    }
}

class SplashActivity : AppCompatActivity() {

    // ✗ Non-static inner class — holds implicit ref to SplashActivity
    inner class SplashHandler : Handler(Looper.getMainLooper()) {
        override fun handleMessage(msg: Message) { navigateToMain() }
    }
    private val handler = SplashHandler()  // queued messages keep Activity alive

    // ✗ Anonymous Runnable — captures 'this' (Activity)
    private fun startTimer() {
        Handler.postDelayed({ doSomething() }, 5000)  // lambda captures Activity
    }
}

// ✓ Static inner class + WeakReference to outer
class SplashActivity : AppCompatActivity() {

    private class SplashHandler(activity: SplashActivity) :
            Handler(Looper.getMainLooper()) {
        private val ref = WeakReference(activity)
        override fun handleMessage(msg: Message) {
            ref.get()?.navigateToMain()  // safe: Activity may be null
        }
    }

    // ✓ Modern: use lifecycleScope instead of Handler entirely
    private fun startTimer() {
        lifecycleScope.launch {
            delay(5000)
            navigateToMain()
        }  // cancelled automatically in onDestroy
    }
}

// ✗ ViewModel storing Activity context
class BadViewModel(val context: Context) : ViewModel() {
    // ViewModel outlives Activity on rotation — Activity leaked!
    fun loadImage() = Glide.with(context).load(url)  // context = Activity
}

// ✗ Custom View caching a Context in a static field
class ThemeHelper {
    companion object {
        var ctx: Context? = null  // set to Activity, never cleared
    }
}

// ✗ Dialog not dismissed — holds Activity window token
class MyActivity : AppCompatActivity() {
    private var dialog: AlertDialog? = null
    override fun onDestroy() {  // dialog showing when Activity dies
        super.onDestroy()  // dialog.dismiss() not called!
    }
}

// ✓ ViewModel using Application context via AndroidViewModel or Hilt
@HiltViewModel
class GoodViewModel @Inject constructor(
    @ApplicationContext private val context: Context  // Application context, safe
) : ViewModel()

// ✓ Always dismiss dialogs in onDestroy
override fun onDestroy() {
    dialog?.dismiss()
    dialog = null
    super.onDestroy()
}

class MainActivity : AppCompatActivity() {

    // ✗ BroadcastReceiver registered, never unregistered
    private val receiver = object : BroadcastReceiver() {
        override fun onReceive(ctx: Context, intent: Intent) { handleBroadcast() }
    }
    override fun onResume() {
        super.onResume()
        registerReceiver(receiver, IntentFilter("ACTION"))  // registered...
    }
    // ... but onPause/onDestroy never calls unregisterReceiver()

    // ✗ LocationManager listener — callback holds Activity reference
    override fun onStart() {
        locationManager.requestLocationUpdates(provider, 0, 0f, locationListener)
    }
    // Missing: locationManager.removeUpdates(locationListener) in onStop()
}

class MainActivity : AppCompatActivity() {

    // ✓ Symmetric: register in onStart, unregister in onStop
    override fun onStart() {
        super.onStart()
        registerReceiver(receiver, filter)
        locationManager.requestLocationUpdates(provider, 0, 0f, locationListener)
    }
    override fun onStop() {
        unregisterReceiver(receiver)
        locationManager.removeUpdates(locationListener)
        super.onStop()
    }

    // ✓ Modern: use Lifecycle-aware components — auto-unregisters
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(LocationObserver(locationManager))
        // LocationObserver implements DefaultLifecycleObserver
        // registers in onStart(), removes in onStop() automatically
    }
}

class DataFragment : Fragment() {

    // ✗ GlobalScope — never cancelled, outlives Fragment
    fun loadData() {
        GlobalScope.launch {
            val data = repo.fetchData()          // Fragment destroyed mid-flight?
            binding.textView.text = data.title   // NPE or view reference on dead Fragment
        }
    }

    // ✗ Custom CoroutineScope not cancelled
    private val scope = CoroutineScope(Dispatchers.Main)
    // Missing: scope.cancel() in onDestroyView/onDestroy

    // ✗ Collecting flow with lifecycleScope without repeatOnLifecycle
    override fun onViewCreated(view: View, savedState: Bundle?) {
        lifecycleScope.launch {
            viewModel.flow.collect { updateUI(it) }  // collects even in background!
        }
    }
}

class DataFragment : Fragment() {

    // ✓ viewModelScope — cancelled in onCleared() automatically
    // ✓ lifecycleScope — cancelled in onDestroy() automatically
    // ✓ viewLifecycleOwner.lifecycleScope — cancelled in onDestroyView()

    override fun onViewCreated(view: View, savedState: Bundle?) {
        viewLifecycleOwner.lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.uiState.collect { render(it) }
                // stops collecting when STOPPED, resumes when STARTED
                // cancelled entirely in onDestroyView
            }
        }
    }

    // ✓ Custom scope: cancel it yourself
    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
    override fun onDestroyView() {
        scope.cancel()
        super.onDestroyView()
    }
}

// ✗ Custom View holding Bitmap without recycle
class AvatarView(context: Context) : View(context) {
    private var avatar: Bitmap? = null

    fun setImage(bmp: Bitmap) {
        avatar = bmp  // old bitmap never recycled if replaced
        invalidate()
    }
    // No onDetachedFromWindow() cleanup — bitmap lives forever
}

// ✗ Large Bitmap decoded on main thread without inSampleSize
val full = BitmapFactory.decodeResource(resources, R.drawable.hero)  // 40MB raw

// ✓ Always use an image loading library (Coil, Glide, Picasso)
// They handle: caching, sampling, recycle, lifecycle-awareness
Coil: binding.imageView.load(url) {
    crossfade(true)
    size(ViewSizeResolver(binding.imageView))  // auto-samples to view size
}  // lifecycle-aware: cancels request when Fragment is destroyed

// ✓ If manual, clean up in onDetachedFromWindow
class AvatarView(context: Context) : View(context) {
    private var avatar: Bitmap? = null

    fun setImage(bmp: Bitmap) {
        avatar?.recycle()  // recycle old before replacing
        avatar = bmp; invalidate()
    }

    override fun onDetachedFromWindow() {
        avatar?.recycle(); avatar = null  // clean up when view removed
        super.onDetachedFromWindow()
    }
}

// ✗ DisposableEffect missing onDispose — observer never removed
@Composable
fun BadObserver(viewModel: MyViewModel) {
    DisposableEffect(viewModel) {
        viewModel.addListener(myListener)
        onDispose { }  // empty onDispose — listener never removed!
    }
}

// ✗ Capturing MutableState in a non-composable lambda that escapes
@Composable
fun BadState() {
    var count by remember { mutableStateOf(0) }
    SomeGlobalObject.listener = { count++ }  // state captured in global callback
    // Composition leaves → count state kept alive by global listener
}

// ✗ collectAsState() instead of collectAsStateWithLifecycle()
val state = viewModel.flow.collectAsState()  // keeps collecting in background

// ✓ DisposableEffect with proper cleanup
@Composable
fun GoodObserver(viewModel: MyViewModel) {
    DisposableEffect(viewModel) {
        viewModel.addListener(myListener)
        onDispose { viewModel.removeListener(myListener) }  // always paired
    }
}

// ✓ Use collectAsStateWithLifecycle — stops when UI goes background
val state = viewModel.flow.collectAsStateWithLifecycle()

// ✓ Never capture Compose state in non-composable scopes
@Composable
fun GoodState(onEvent: () -> Unit) {  // pass callback up, not state out
    SomeWidget(onClick = onEvent)  // Compose UI never leaks into global objects
}

// build.gradle.kts — add to debug dependencies only
debugImplementation("com.squareup.leakcanary:leakcanary-android:2.14")
// That's it. No Application.onCreate() code. ContentProvider auto-installs it.

// ── What LeakCanary does automatically ──
// 1. Hooks ActivityLifecycleCallbacks — watches every Activity
// 2. After onDestroy(), waits 5 seconds
// 3. Creates WeakReference to the Activity
// 4. Forces GC, checks if WeakReference was cleared
// 5. If not cleared → suspected leak → dumps HPROF
// 6. Analyzes heap in background → finds shortest GC root path
// 7. Shows notification with full leak trace

// ── Custom watched objects (beyond Activities) ──
class MyService : Service() {
    override fun onDestroy() {
        super.onDestroy()
        AppWatcher.objectWatcher.expectWeaklyReachable(this, "MyService destroyed")
    }
}

// ── Reading a LeakCanary trace ──
// ┬───────────────────────────────────────────
// │ GC Root: static field AnalyticsManager.INSTANCE
// │                                         ↓
// │ AnalyticsManager.context                ↓ (LEAK SUSPECT)
// │                                         ↓
// ╰→ MainActivity (5 instances, 48 MB retained)
// ┴───────────────────────────────────────────